/*Treap <Template>
 *Recursive Version
 *relic@20070718
 */

#include <cstdio>
#include <cstdlib>
#include <ctime>

template<typename _Tp>
struct _node {
	_Tp data;
	int pri;
	_node * left, * right;
	_node(const _Tp & x = _Tp()) : data(x), pri(rand()) {
		left = right = NULL;
	}
};
template<typename _Tp>
struct Treap {
	_node<_Tp> * root;
	Treap() : root(NULL){srand(time(NULL));}
	void rotR(_node<_Tp> * & p);
	void rotL(_node<_Tp> * & p);
	void insert(const _Tp & x);
	void insert(const _Tp & x, _node<_Tp> * & p);
	void remove(const _Tp & x);
	void remove(const _Tp & x, _node<_Tp> * & p);
	_Tp * find(const _Tp & x);
	_node<_Tp> * find(const _Tp &x, _node<_Tp> * p);
	void clear();
	void clear(_node<_Tp> * & p);
	void inorder(const _node<_Tp> * r);
};
template<typename _Tp>
void Treap<_Tp>::rotR(_node<_Tp> * & p) {
	_node<_Tp> * x = p->left;
	p->left = x->right;
	x->right = p;
	p = x;
}
template<typename _Tp>
void Treap<_Tp>::rotL(_node<_Tp> * & p) {
	_node<_Tp> * x = p->right;
	p->right = x->left;
	x->left = p;
	p = x;
}
template<typename _Tp>
void Treap<_Tp>::insert(const _Tp & x, _node<_Tp> * & p) {
	if (p == NULL) {
		p = new _node<_Tp>(x);
	} else if (x < p->data) {
		insert(x, p->left);
		if (p->left->pri < p->pri)
			rotR(p);
	} else {
		insert(x, p->right);
		if (p->right->pri < p->pri)
			rotL(p);
	}
}
template<typename _Tp>
void Treap<_Tp>::remove(const _Tp & x, _node<_Tp> * & p) {
	if (p == NULL) {
		return ;
	} else if (x < p->data) {
		remove(x, p->left);
	} else if (p->data < x) {
		remove(x, p->right);
	} else if (p->left != NULL && p->right != NULL) {
		if (p->left->pri < p->right->pri) {
			rotR(p);
		} else {
			rotL(p);
		}
		remove(x, p);
	} else {
		_node<_Tp> * tmp = p;
		p = p->left ? p->left : p->right;
		delete tmp;
	}
}
template<typename _Tp>
_node<_Tp> * Treap<_Tp>::find(const _Tp &x, _node<_Tp> * p) {
	if (p == NULL)
		return NULL;
	else if (p->data == x)
		return p;
	else if (x < p->data)
		return find(x, p->left);
	else
		return find(x, p->right);
}
template<typename _Tp>
_Tp * Treap<_Tp>::find(const _Tp & x) {
	_node<_Tp> *p = find(x, root);
	return p != NULL ? &p->data : NULL;
}
template<typename _Tp>
void Treap<_Tp>::insert(const _Tp & x) {
	insert(x, root);
}
template<typename _Tp>
void Treap<_Tp>::remove(const _Tp & x) {
	remove(x, root);
}
template<typename _Tp>
void Treap<_Tp>::clear(_node<_Tp> * & p) {
	if (p != NULL) {
		clear(p->left);
		clear(p->right);
		delete p;
	}
	p = NULL;
}
template<typename _Tp>
void Treap<_Tp>::clear() {
	clear(root);
}
template<typename _Tp>
void Treap<_Tp>::inorder(const _node<_Tp> * r) {
	if(r == NULL)
		return ;
	else {
		printf("%d -> %d -> %d\n", r->data, r->left ? r->left->data : 0, r->right ? r->right->data : 0);
		inorder(r->left);
		inorder(r->right);
	}
}
int main() {
	int n;
	Treap<int> tree;
	scanf("%d", &n);
	for (int i = 0; i < n; ++ i) {
		int t;
		scanf("%d", &t);
		tree.insert(t);
	}
	tree.inorder(tree.root);
	while (scanf("%d", &n) != EOF) {
		if (tree.find(n))
			printf("%d Exist\n", n);
		else
			printf("%d Not Exist\n", n);
		tree.remove(n);
		tree.inorder(tree.root);
	}
	tree.clear();
	return 0;
}
